/**
 * 激活码专用API服务
 * 不进行JWT验证和管理员权限验证
 * 调用原系统中无JWT验证的MP接口
 */

const { request } = require('./request');
const api = require('./api.js');

// 获取全局server URL的函数
const getBaseUrl = () => {
  const app = getApp();
  return app && app.globalData && app.globalData.serverUrl ?
    app.globalData.serverUrl : 'http://127.0.0.1:5000';
};

// API路径
const API = {
  // 激活码相关接口
  CODES_LIST: '/api/admin/mp/activation-codes',
  CODES_DATA: '/api/admin/mp/get-codes-data',
  CODE_QUERY:'/api/admin/mp/query-code',
  CODES_STATISTICS: '/api/admin/mp/activation-codes/statistics',
  MARK_COPIED: '/api/admin/mp/activation-codes/mark-copied/',
  MARK_EXPORTED: '/api/admin/mp/activation-codes/mark-exported/',
  BATCH_MARK_COPIED: '/api/admin/mp/activation-codes/batch-mark-copied',
  BATCH_MARK_EXPORTED: '/api/admin/mp/activation-codes/batch-mark-exported',
  GENERATE_CODES: '/api/admin/mp/activation-codes/generate',
  CHECK_PERMISSION: '/api/admin/mp/check-permission'

};

/**
 * 发送请求
 * @param {string} url - API路径
 * @param {string} method - 请求方法
 * @param {object} data - 请求数据
 * @param {boolean} showLoading - 是否显示加载提示
 */
const sendRequest = (url, method = 'GET', data = {}, showLoading = true) => {
  return new Promise((resolve, reject) => {
    // 显示加载中
    if (showLoading) {
      wx.showLoading({ title: '加载中...' });
    }

    // 获取当前BASE_URL
    const BASE_URL = getBaseUrl();

    console.log(`[卡密API] ${method} ${url}`, data);
    console.log(`[完整URL] ${BASE_URL + url}`);

    wx.request({
      url: BASE_URL + url,
      method: method,
      data: data,
      header: {
        'content-type': method.toUpperCase() === 'POST' ? 'application/json' : 'application/x-www-form-urlencoded'
        // 原系统MP接口不需要认证头
      },
      success: (res) => {
        console.log(`[卡密API响应] ${res.statusCode}`, res.data);

        // 处理响应
        if (res.statusCode === 200) {
          resolve(res.data);
        } else {
          console.error(`[卡密API错误] ${res.statusCode}`, res.data);

          wx.showToast({
            title: res.data.message || `请求失败(${res.statusCode})`,
            icon: 'none'
          });

          // 即使失败也尝试返回数据，方便调试
          if (res.data) {
            resolve(res.data);
          } else {
            reject({ message: `请求失败(${res.statusCode})` });
          }
        }
      },
      fail: (err) => {
        console.error(`[卡密API错误] ${url}`, err);
        wx.showToast({
          title: '网络错误',
          icon: 'none'
        });
        reject(err);
      },
      complete: () => {
        if (showLoading) {
          wx.hideLoading();
        }
      }
    });
  });
};

/**
 * 获取激活码列表
 * @param {object} params - 查询参数，支持以下字段:
 * - page: 页码
 * - per_page: 每页数量
 * - status: 状态(0未使用，1已使用)
 * - is_copied: 是否已复制(1已复制)
 * - is_exported: 是否已导出(1已导出)
 * - agent_id: 代理ID
 * - sort_by: 排序字段(create_time, copied_time, exported_time, used_time, priority)
 * - sort_order: 排序方向(asc, desc)
 */
const getActivationCodes = (params = {}) => {
  // 优化排序参数
  // 如果使用priority排序，需要特殊处理
  if (params.sort_by === 'priority') {
    // priority是一个前端概念，表示未导出未复制的优先级更高
    // 后端没有这个字段，我们使用默认排序，但会在前端做额外处理
    delete params.sort_by;
  }

  return sendRequest(API.CODES_LIST, 'GET', params);
};
/**
 * 获取激活码列表
 * @param {object} params - 查询参数，支持以下字段:
 * - page: 页码
 * - per_page: 每页数量
 * - status: 状态(0未使用，1已使用)
 * - is_copied: 是否已复制(1已复制)
 * - is_exported: 是否已导出(1已导出)
 * - agent_id: 代理ID
 * - sort_by: 排序字段(create_time, copied_time, exported_time, used_time, priority)
 * - sort_order: 排序方向(asc, desc)
 */
const getCodesData = (params = {}) => {
  return sendRequest(API.CODES_DATA, 'GET', params);
};
/**
 * 获取激活码统计信息
 * @param {number|string} agentId - 代理ID
 */
const getCodesStatistics = (agentId = null) => {
  // 确保agent_id是字符串类型
  const params = agentId ? { agent_id: String(agentId) } : {};
  return sendRequest(API.CODES_STATISTICS, 'GET', params);
};

/**
 * 标记激活码为已复制
 * @param {number} codeId - 激活码ID
 */
const markAsCopied = (codeId) => {
  console.log(`[标记复制] 调用API: ${API.MARK_COPIED}${codeId}`);

  // 特殊处理，确保URL路径正确
  if (!codeId) {
    console.error('[标记复制] 错误: 缺少激活码ID');
    return Promise.reject(new Error('缺少激活码ID'));
  }

  return sendRequest(API.MARK_COPIED + codeId, 'POST', {}, false);
};

/**
 * 标记激活码为已导出
 * @param {number} codeId - 激活码ID
 */
const markAsExported = (codeId) => {
  console.log(`[标记导出] 调用API: ${API.MARK_EXPORTED}${codeId}`);

  // 特殊处理，确保URL路径正确
  if (!codeId) {
    console.error('[标记导出] 错误: 缺少激活码ID');
    return Promise.reject(new Error('缺少激活码ID'));
  }

  return sendRequest(API.MARK_EXPORTED + codeId, 'POST', {}, false);
};

/**
 * 批量标记激活码为已复制
 * @param {array} codeIds - 激活码ID数组
 */
const batchMarkCopied = (codeIds = []) => {
  console.log('[批量标记复制] 调用API:', API.BATCH_MARK_COPIED, '参数:', { code_ids: codeIds });

  if (!codeIds || codeIds.length === 0) {
    console.error('[批量标记复制] 错误: 缺少激活码ID');
    return Promise.reject(new Error('缺少激活码ID'));
  }

  return sendRequest(API.BATCH_MARK_COPIED, 'POST', { code_ids: codeIds });
};

/**
 * 批量标记激活码为已导出
 * @param {array} codeIds - 激活码ID数组
 */
const batchMarkExported = (codeIds = []) => {
  console.log('[批量标记导出] 调用API:', API.BATCH_MARK_EXPORTED, '参数:', { code_ids: codeIds });

  if (!codeIds || codeIds.length === 0) {
    console.error('[批量标记导出] 错误: 缺少激活码ID');
    return Promise.reject(new Error('缺少激活码ID'));
  }

  return sendRequest(API.BATCH_MARK_EXPORTED, 'POST', { code_ids: codeIds });
};

/**
 * 生成激活码
 * @param {object} params - 生成参数
 */
const generateCodes = (params = {}) => {
  return sendRequest(API.GENERATE_CODES, 'POST', params);
};

/**
 * 检查用户权限
 * @param {number} userId - 用户ID
 */
const checkPermission = (userId) => {
  // 确保userId是字符串类型
  return sendRequest(API.CHECK_PERMISSION, 'GET', { user_id: String(userId) });
};

// 代理卡密管理相关API封装
const codeApi = {
  /**
   * 检查代理权限
   * @param {number} userId - 用户ID
   * @returns {Promise} - 请求Promise
   */
  checkPermission(userId) {
    return request(`${api.checkAdminPermission}?user_id=${userId}`, 'GET');
  },
  getCodes(params = {}) {
    return request(API.CODES_DATA, 'GET', params);
  },

  queryCode(params = {}) {
    return request(API.CODE_QUERY, 'GET', params);
  },

  /**
   * 获取激活码统计信息
   * @param {number} agentId - 代理ID 
   * @returns {Promise} - 请求Promise
   */
  getCodesStatistics(agentId) {
    const url = `${api.admin_codes}/statistics${agentId ? `?agent_id=${agentId}` : ''}`;
    return request(url, 'GET');
  },

  /**
   * 获取激活码列表
   * @param {Object} params - 查询参数
   * @returns {Promise} - 请求Promise
   */
  getActivationCodes(params = {}) {
    // 构建参数字符串
    const queryParams = Object.keys(params)
      .map(key => `${key}=${encodeURIComponent(params[key])}`)
      .join('&');

    const url = `${api.admin_codes}${queryParams ? `?${queryParams}` : ''}`;
    return request(url, 'GET');
  },

  /**
   * 标记激活码为已复制
   * @param {number} codeId - 激活码ID
   * @returns {Promise} - 请求Promise
   */
  markAsCopied(codeId) {
    return request(`${api.admin_codes}/mark-copied/${codeId}`, 'POST');
  },

  /**
   * 标记激活码为已导出
   * @param {number} codeId - 激活码ID
   * @returns {Promise} - 请求Promise
   */
  markAsExported(codeId) {
    return request(`${api.admin_codes}/mark-exported/${codeId}`, 'POST');
  },

  /**
   * 批量标记为已复制
   * @param {Array} codeIds - 激活码ID数组
   * @returns {Promise} - 请求Promise
   */
  batchMarkCopied(codeIds) {
    return request(`${api.admin_codes}/batch-mark-copied`, 'POST', {
      code_ids: codeIds
    });
  },

  /**
   * 批量标记为已导出
   * @param {Array} codeIds - 激活码ID数组
   * @returns {Promise} - 请求Promise
   */
  batchMarkExported(codeIds) {
    return request(`${api.admin_codes}/batch-mark-exported`, 'POST', {
      code_ids: codeIds
    });
  },

  /**
   * 生成激活码
   * @param {Object} params - 生成参数
   * @returns {Promise} - 请求Promise
   */
  generateCodes(params) {
    return request(api.admin_generate_codes, 'POST', params);
  },

  /**
   * 删除激活码
   * @param {number} codeId - 激活码ID
   * @returns {Promise} - 请求Promise
   */
  deleteCode(codeId) {
    return request(`${api.admin_delete_code}${codeId}`, 'DELETE');
  }
};

module.exports = codeApi; 